<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<style>
			ul{
				width: 700px;
				height: 500px;
				border: 1px solid #000;
			}	
		</style>
	</head>
	<body>
		<ul>
			<li></li>
			<li></li>
			<li></li>
			<li></li>
			<li></li>
			<li></li>
		</ul>

		<!-- 
		 # 二、常用 Composition API(组合式API)
		 官方文档: https://v3.cn.vuejs.org/guide/composition-api-introduction.html
		 ## 1.拉开序幕的setup
		 1. 理解：Vue3.0中一个新的配置项，值为一个函数。
		 2. setup是所有 Composition API（组合API“ 表演的舞台 ”
		 4. 组件中所用到的：数据、方法等等，均要配置在setup中。
		 5. setup函数的两种返回值：
		    1. 若返回一个对象，则对象中的属性、方法, 在模板中均可以直接使用。（重点关注！）
				setup(){
					let name ='张三'
					let age = 18
					function showAge(){
						alert(age)
					}
					return {
						name,age,showAge
					}
				}
				***此处测试 属性 会丢失响应式
		    2. 若返回一个渲染函数：则可以自定义渲染内容。（了解）
				import {h} from 'vue'
				setup(){
					let name ='张三'
					let age = 18
					function showAge(){
						alert(age)
					}
					return ()=>h('h1','天青色')
				}
				***此处页面些什么都没了  只有 渲染函数里面的东西
				
				注:vue2 的  data  methods 都还是可以使用,不建议一起使用
				vue2的方法里面 可以读取到 vue2以及vue3的数据 以及方法
				vue3的方法 不能读取到 vue2 里面的 数据 以及方法
				vue2跟vue3的 属性 同名 冲突的时候 以 后配置的为主
				主要用于过度 后续肯定会移除
		 
		 ##  2.ref函数
		 
		 - 作用: 定义一个响应式的数据
		 - 语法: ```const xxx = ref(initValue)``` 
		   - 创建一个包含响应式数据的引用对象（reference对象，简称ref对象）
		   - JS中操作数据： ```xxx.value```
		   - 模板中读取数据: 不需要.value，直接：```<div>{{xxx}}</div>```
			 import {ref} from 'vue'
			 setup(){
			 	let name =ref('张三')  //引用对象
			 	let age = ref(18)
			 	function changeAge(){
			 		age.value = 66
			 	}
			 	return{
			 		name,age,changeAge
			 	}
			 }
			 
			 引用数据类型 
			 import {ref} from 'vue'
			 setup(){
			 	let name =ref('张三')  //引用对象
			 	let age = ref(18)
				let   =ref({
					scroe:90,
					marry:true
				})
			 	function changeAge(){
			 		age.value = 66
			 		.value.scroe = 100
			 	}
			 	return{
			 		name,age,changeAge,
			 	}
			 }
			 注:ref 基本数据类型使用的 是 defineProperty  引用数据类型  里面使用的是  Proxy
			 
		 - 备注：
		   - 接收的数据可以是：基本类型、也可以是对象类型。
		   - 基本类型的数据：响应式依然是靠``ect.defineProperty()``的```get```与```set```完成的。
		   - 对象类型的数据：内部  求助 了Vue3.0中的一个新函数—— ```reactive```函数。
		 
		 ## 3.reactive函数(响应式函数) 
		 能不能传入基本数据类型
		 
		 import {ref,reactive} from 'vue'
		 setup(){
		 	let name =ref('张三')  //引用对象
		 	let age = ref(18)
			let   = reactive( {
				scroe:90,
				marry:true
			})
		 	function changeAge(){
		 		age.value = 66
		 		.scroe = 100
		 	}
		 	return{
		 		name,age,changeAge,
		 	}
		 }
		 
		 - reactive定义的响应式数据是“深层次的”。 .a.b.c 都能监听 
		 - 数组的监听呢? 也能处理数组类型的数据 并且能够  arr[1] 修改并且是响应式
		 - 内部基于 ES6 的 Proxy 实现，通过代理对象操作源对象内部数据进行操作。
		 
		 
		 
		 ## 4.Vue3.0中的响应式原理
		 
		 ### vue2.x的响应式
		 
		 - 实现原理：  defineProperty
		   - 对象类型：通过```ect.defineProperty()```对属性的读取、修改进行拦截（数据劫持）。
		   
		   - 数组类型：通过重写更新数组的一系列方法来实现拦截。（对数组的变更方法进行了包裹）。
		   
		     ```js
		     ect.defineProperty(data, 'count', {
		         get () {}, 
		         set () {}
		     })
		     ```
		 
		 - 存在问题：
		   - 新增属性、删除属性, 界面不会更新。
		   - 直接通过下标修改数组,修改数组长度, 界面不会自动更新。
		 
		 ### Vue3.0的响应式
			基础数据类型 还是defineProperty
			复杂数据类型 通过Proxy
		 - 实现原理: 
		   - 通过Proxy（代理）:  拦截对象中任意属性的变化, 包括：属性值的读写、属性的添加、属性的删除等。
		   - 通过Reflect（反射）:  对源对象的属性进行操作。
		   - MDN文档中描述的Proxy与Reflect：
		     - Proxy：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_ects/Proxy
		     
		     - Reflect：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_ects/Reflect
		     
		       ```js
		       new Proxy(data, {
		       	// 拦截读取属性值
		           get (target, prop) {
		           	return Reflect.get(target, prop)
		           },
		           // 拦截设置属性值或添加新属性
		           set (target, prop, value) {
		           	return Reflect.set(target, prop, value)
		           },
		           // 拦截删除属性
		           deleteProperty (target, prop) {
		           	return Reflect.deleteProperty(target, prop)
		           }
		       })
		       
		       proxy.name = 'tom'   
		       ```
		 
		 ## 5.reactive对比ref
		 
		 -  从定义数据角度对比：
		    -  ref用来定义：基本类型数据 也可以定义复杂数据类型
		    -  reactive用来定义：对象（或数组）类型数据
		    -  备注：ref也可以用来定义对象（或数组）类型数据, 它内部会自动通过```reactive```转为代理对象
		 -  从原理角度对比：
		    -  ref通过``ect.defineProperty()``的```get```与```set```来实现响应式（数据劫持）。
		    -  reactive通过使用Proxy来实现响应式（数据劫持）, 并通过Reflect操作<strong style="color:orange">源对象内部的数据。
		 -  从使用角度对比：
		    -  ref定义的数据：操作数据需要```.value```，读取数据时模板中直接读取不需要```.value```。
		    -  reactive定义的数据：操作数据与读取数据：均不需要```.value```。
		 
		 ## 6.setup的两个注意点
		 
		 props 传参 接收与否的区别
		 插槽内容存在
		 
		 - setup执行的时机
		   - 在beforeCreate之前执行一次，this是undefined。
					所以在 setup里面 不能使用 this
		   
		 - setup的参数
		   - props：值为对象，包含：组件外部传递过来，且组件内部声明接收了的属性。
		   - context：上下文对象
		     - attrs: 值为对象，包含：组件外部传递过来，但没有在props配置中声明的属性, 相当于 ```this.$attrs```。
		     - slots: 收到的插槽内容, 相当于 ```this.$slots```。(在vue3里面 使用 v-solt:qer 具名插槽)
		     - emit: 分发自定义事件的函数, 相当于 ```this.$emit```。(注意 必须跟props一样 声明一下 emits:['eventName'])
		 
		 
		 ## 7.计算属性与监视
		 ### 1.computed函数
		 
		 - 与Vue2.x中computed配置功能一致
			vue2的写法在 vue3里面也能成功  但是 不建议
		 - 写法
			
		   ```js
		   import {computed} from 'vue'
		   
		   setup(){
		       ...
		   	//计算属性——简写
		       let fullName = computed(()=>{
		           return person.firstName + '-' + person.lastName
		       })
		       //计算属性——完整
		       let fullName = computed({
		           get(){
		               return person.firstName + '-' + person.lastName
		           },
		           set(value){
		               const nameArr = value.split('-')
		               person.firstName = nameArr[0]
		               person.lastName = nameArr[1]
		           }
		       })
		   }
		   ```
		 
		 ### 2.watch函数
		 
		 - 与Vue2.x中watch配置功能一致
		 
		 - 两个小“坑”：
		   - 监视reactive定义的响应式数据时：oldValue无法正确获取、强制开启了深度监视（deep配置失效）。
		   - 监视reactive定义的响应式数据中某个属性时：deep配置有效。
		   
		   ```js
		   //情况一：监视ref定义的响应式数据
		   watch(sum,(newValue,oldValue)=>{
		   	console.log('sum变化了',newValue,oldValue)
		   },{immediate:true})
		   
		   //情况二：监视多个ref定义的响应式数据
		   watch([sum,msg],(newValue,oldValue)=>{
		   	console.log('sum或msg变化了',newValue,oldValue)
		   }) 
		   
		   /* 情况三：监视reactive定义的响应式数据
		   			若watch监视的是reactive定义的响应式数据，则无法正确获得oldValue！！
		   			若watch监视的是reactive定义的响应式数据，则强制开启了深度监视 
		   */
		   watch(person,(newValue,oldValue)=>{
		   	console.log('person变化了',newValue,oldValue)
		   },{immediate:true,deep:false}) //此处的deep配置不再奏效
		   
		   //情况四：监视reactive定义的响应式数据中的某个属性  第一个参数必须是带返回值的函数
		   watch(()=>person.job,(newValue,oldValue)=>{
		   	console.log('person的job变化了',newValue,oldValue)
		   },{immediate:true,deep:true}) 
		   
		   //情况五：监视多个reactive定义的响应式数据中的某些属性
		   watch([()=>person.job,()=>person.name],(newValue,oldValue)=>{
		   	console.log('person的job变化了',newValue,oldValue)
		   },{immediate:true,deep:true})
		   
		   //特殊情况
		   watch(()=>person.job,(newValue,oldValue)=>{
		       console.log('person的job变化了',newValue,oldValue)
		   },{deep:true}) //此处由于监视的是reactive素定义的对象中的某个属性，所以deep配置有效
		   ```
			 关于value的问题  监听 ref 基本数据类型不需要 value  监听ref 复杂数据类型 需要 value  
			 因为 value 其实是借助 reactive 生成的     
			 监听复杂数据类型 不 加 value  那么必须要开启深度监听
		 
		 ### 3.watchEffect函数
		
		 - watch的套路是：既要指明监视的属性，也要指明监视的回调。
		 
		 - watchEffect的套路是：不用指明监视哪个属性，监视的回调中用到哪个属性，那就监视哪个属性。
		 
		 - watchEffect有点像computed：
		 
		   - 但computed注重的计算出来的值（回调函数的返回值），所以必须要写返回值。
		   - 而watchEffect更注重的是过程（回调函数的函数体），所以不用写返回值。
		 
		   ```js
			 import {watchEffect } from 'vue'
		   //watchEffect所指定的回调中用到的数据只要发生变化，则直接重新执行回调。
		   let stopWatcher = watchEffect(()=>{
		       const x1 = sum.value
		       const x2 = person.age
		       console.log('watchEffect配置的回调执行了')
		   })
			 
			 stopWatcher()  停止观察者
		   ```
		 
		 ## 8.生命周期
		 
		 - Vue3.0中可以继续使用Vue2.x中的生命周期钩子，但有有两个被更名：
		   - ```beforeDestroy```改名为 ```beforeUnmount```
		   - ```destroyed```改名为 ```unmounted```
		 - Vue3.0也提供了 Composition API 形式的生命周期钩子，与Vue2.x中钩子对应关系如下：
		   - `beforeCreate`===>`setup()`
		   - `created`=======>`setup()`
		   - `beforeMount` ===>`onBeforeMount`
		   - `mounted`=======>`onMounted`
		   - `beforeUpdate`===>`onBeforeUpdate`
		   - `updated` =======>`onUpdated`
		   - `beforeUnmount` ==>`onBeforeUnmount`
		   - `unmounted` =====>`onUnmounted`
		 
		 ##
		 
			 使用
			 import { click } from "./click";
				export default {
					setup() {
						const { x, y } = click();
						// other logic...
						return { x, y };
					},
				};
		
		 
		 ## 10.toRef
		 
		 
		 属性使用 不方便 如果 
			1. 直接返回 使用的时候 需要 .操作
			const person = ref({
				name:'张三',
				age:18,
				attr:{
					a:20
				}
			})
			return {
				person
			}
			2.这样返回丢失响应式
			const person = ref({
				name:'张三',
				age:18,
				attr:{
					a:20
				}
			})
			return {
				name:person.name,
				age:person.age,
				a:person.attr.a,
			}
			3.使用toRef就可以正常使用
			const person = ref({
				name:'张三',
				age:18,
				attr:{
					a:20
				}
			})
			return {
				name:toRef(person,'name'),
				age:toRef(person,'age'),
				a:toRef(person.attr,'a'),
			}
			4. 思考不如直接 将返回的 用ref ?这样行不行?
			const person = ref({
				name:'张三',
				age:18,
				attr:{
					a:20
				}
			})
			return {
				name:ref(person.name),
				age:ref(person.age),
				a:ref(person.attr.a),
			}
			可以借用computed 演示一下
			5. 简化
			const person = ref({
				name:'张三',
				age:18,
				attr:{
					a:20
				}
			})
			return {
				...toRefs(person.value)
			}
			6. 优化
			const person = reactive({
				name:'张三',
				age:18,
				attr:{
					a:20
				}
			})
			return {
				...toRefs(personC)
			}
		 
		 - 作用：创建一个 ref 对象，其value值指向另一个对象中的某个属性。
		 - 语法：```const name = toRef(person,'name')```
		 - 应用:   要将响应式对象中的某个属性单独提供给外部使用时。
		 注意 toRefs 必须要是一个reactive对象
		 
		 
		 - 扩展：```toRefs``` 与```toRef```功能一致，但可以批量创建多个 ref 对象，语法：```toRefs(person)```
		 
		 -->
	</body>
</html>